JuMP's macros create global variables, which are not seen by Pluto. For example, @variable(model, 0 < x < 1) defines a global variable called x, while Pluto thinks that the global variable x was referenced, not assigned.
There are two ways to solve this.
Part 2a: let block (recommended)
Place the macros inside a let block, to locally scope any secretly created variables.
⛔️ Don't:
begin
model = Model(GLPK.Optimizer)
@variable(model, 20 < y < 30)
# global variable y is now defined, but Pluto does not know it
...
end
✔️ Do:
let
global model = Model(GLPK.Optimizer)
@variable(model, 20 < y < 30)
# locally scoped variable y is now defined. Pluto does not know about it, but since the global scope is unaffected, this is fine
...
end
Because JuMP's macros modify a model, it is important the the model construction is contained in a single cell. Use a let block (more in Part 2).
⛔️ Don't:
model = Model(GLPK.Optimizer)
@variable(model, 20 < y < 30)
✔️ Do:
let
global model = Model(GLPK.Optimizer)
@variable(model, 20 < y < 30)
...
end
optimize!
Similarly, optimize! will modify the model, so I recommend calling it in the same cell as the model construction.
If, for the purpose of a narrative, you need the optimization to happen in a different cell, then use a "new state, new name" trick:
begin
optimize!(model)
model_optimized = model
end
In other cells, reference model_optimized to access model to guarantee that the model optimization has already happened:
# in other cells
value(model_optimized[:x])
mimetext/htmlrootassigneelast_run_timestampA
kpersist_js_state·has_pluto_hook_features§cell_id$759c0a90-bb03-456e-bbf6-8bf80b249c07depends_on_disabled_cells§runtime %published_object_keysdepends_on_skipped_cells§errored$69a565bc-e250-4105-9b6b-3b9879dcb417queued¤logsrunning¦outputbody"OPTIMAL::TerminationStatusCode = 1mimetext/plainrootassigneelast_run_timestampA*=:persist_js_state·has_pluto_hook_features§cell_id$69a565bc-e250-4105-9b6b-3b9879dcb417depends_on_disabled_cells§runtimeJ4published_object_keysdepends_on_skipped_cells§errored$95e0721d-321f-478c-8d02-0ac070008a5bqueued¤logsrunning¦outputbodyA JuMP Model
Maximization problem with:
Variables: 2
Objective function type: AffExpr
`JuMP.AffExpr`-in-`MathOptInterface.LessThan{Float64}`: 1 constraint
`JuMP.VariableRef`-in-`MathOptInterface.GreaterThan{Float64}`: 2 constraints
`JuMP.VariableRef`-in-`MathOptInterface.LessThan{Float64}`: 2 constraints
Model mode: AUTOMATIC
CachingOptimizer state: ATTACHED_OPTIMIZER
Solver name: GLPK
Names registered in the model: con, x, ymimetext/plainrootassigneemodel_optlast_run_timestampA @persist_js_state·has_pluto_hook_features§cell_id$95e0721d-321f-478c-8d02-0ac070008a5bdepends_on_disabled_cells§runtime (|0published_object_keysdepends_on_skipped_cells§errored$d5b9c438-b1e7-4417-870f-afdfc4ee7672queued¤logsrunning¦outputbodyG
How to use JuMP in Pluto?
JuMP uses macros to form a domain-specific language. That is very cool! but unfortunately, Pluto has trouble understanding code with macros. This is a difficult problem that we currently working on, and it is getting closer to being fixed!
For any cell, it is important that Pluto correctly understands which variables are referenced and which are defined. Pluto's runtime uses this information to keep your global scope clean, and to reactively re-run cells.
mimetext/htmlrootassigneelast_run_timestampAdpersist_js_state·has_pluto_hook_features§cell_id$d5b9c438-b1e7-4417-870f-afdfc4ee7672depends_on_disabled_cells§runtime spublished_object_keysdepends_on_skipped_cells§errored$2717450b-8e9d-4be4-9156-53b2020a2e5dqueued¤logsrunning¦outputbody]Max 5 x + 3 y
Subject to
con : x + 5 y ≤ 3.0
x ≥ 0.0
y ≥ 0.0
x ≤ 1.0
y ≤ 30.0
mimetext/plainrootassigneelast_run_timestampA0persist_js_state·has_pluto_hook_features§cell_id$2717450b-8e9d-4be4-9156-53b2020a2e5ddepends_on_disabled_cells§runtime8[published_object_keysdepends_on_skipped_cells§errored$946b13ae-65f2-4844-a38a-693b2f01bad4queued¤logsrunning¦outputbody0.4mimetext/plainrootassigneelast_run_timestampACxpersist_js_state·has_pluto_hook_features§cell_id$946b13ae-65f2-4844-a38a-693b2f01bad4depends_on_disabled_cells§runtime published_object_keysdepends_on_skipped_cells§errored$b99f3213-f2c4-4d85-b34c-a60052571af3queued¤logsrunning¦outputbody-
""")metadatashow_logsèdisabled®skip_as_script«code_folded$8bc3d43a-1460-498b-baa8-fcb9a3338457cell_id$8bc3d43a-1460-498b-baa8-fcb9a3338457codeٹmd"""
To access variables from the model that are hidden by a let block, use the alternative syntax:
⛔️ Don't:
```julia
value(y)
```
✔️ Do:
```julia
value(model[:y])
```
"""metadatashow_logsèdisabled®skip_as_script«code_folded$ce6d95f3-d745-4215-844c-727c9d90861dcell_id$ce6d95f3-d745-4215-844c-727c9d90861dcodeJmd"""
## Part 2: secret definitions
JuMP's macros create global variables, which are not seen by Pluto. For example, `@variable(model, 0 < x < 1)` defines a global variable called `x`, while Pluto thinks that the global variable `x` was *referenced*, not assigned.
There are two ways to solve this.
### Part 2a: `let` block (recommended)
Place the macros inside a `let` block, to locally scope any secretly created variables.
⛔️ Don't:
```julia
begin
model = Model(GLPK.Optimizer)
@variable(model, 20 < y < 30)
# global variable y is now defined, but Pluto does not know it
...
end
```
✔️ Do:
```julia
let
global model = Model(GLPK.Optimizer)
@variable(model, 20 < y < 30)
# locally scoped variable y is now defined. Pluto does not know about it, but since the global scope is unaffected, this is fine
...
end
```
"""metadatashow_logsèdisabled®skip_as_script«code_folded$759c0a90-bb03-456e-bbf6-8bf80b249c07cell_id$759c0a90-bb03-456e-bbf6-8bf80b249c07codemd"""
## Part 1: model mutations
Because JuMP's macros _modify_ a model, it is important the the **model construction is contained in a single cell**. Use a `let` block (more in Part 2).
⛔️ Don't:
```julia
model = Model(GLPK.Optimizer)
```
```julia
@variable(model, 20 < y < 30)
```
✔️ Do:
```julia
let
global model = Model(GLPK.Optimizer)
@variable(model, 20 < y < 30)
...
end
```
#### optimize!
Similarly, `optimize!` will _modify_ the model, so I recommend calling it in the same cell as the model construction.
If, for the purpose of a narrative, you need the optimization to happen in a different cell, then use a "new state, new name" trick:
```julia
begin
optimize!(model)
model_optimized = model
end
```
In other cells, reference `model_optimized` to access `model` to guarantee that the model optimization has already happened:
```julia
# in other cells
value(model_optimized[:x])
```
"""metadatashow_logsèdisabled®skip_as_script«code_folded$69a565bc-e250-4105-9b6b-3b9879dcb417cell_id$69a565bc-e250-4105-9b6b-3b9879dcb417codetermination_status(model_opt)metadatashow_logsèdisabled®skip_as_script«code_folded$95e0721d-321f-478c-8d02-0ac070008a5bcell_id$95e0721d-321f-478c-8d02-0ac070008a5bcode,model_opt = let
optimize!(model)
model
endmetadatashow_logsèdisabled®skip_as_script«code_folded$d5b9c438-b1e7-4417-870f-afdfc4ee7672cell_id$d5b9c438-b1e7-4417-870f-afdfc4ee7672codemd"""
# How to use JuMP in Pluto?
JuMP uses macros to form a domain-specific language. That is very cool! but unfortunately, Pluto has trouble understanding code with macros. This is a difficult problem that we currently working on, and it is getting closer to being fixed!
For any cell, it is important that Pluto correctly understands which variables are **referenced** and which are **defined**. Pluto's runtime uses this information to keep your global scope clean, and to reactively re-run cells.
"""metadatashow_logsèdisabled®skip_as_script«code_folded$2717450b-8e9d-4be4-9156-53b2020a2e5dcell_id$2717450b-8e9d-4be4-9156-53b2020a2e5dcodeText(model)metadatashow_logsèdisabled®skip_as_script«code_folded$946b13ae-65f2-4844-a38a-693b2f01bad4cell_id$946b13ae-65f2-4844-a38a-693b2f01bad4codevalue(model_opt[:y])metadatashow_logsèdisabled®skip_as_script«code_folded$b99f3213-f2c4-4d85-b34c-a60052571af3cell_id$b99f3213-f2c4-4d85-b34c-a60052571af3codemd"""
# Example
"""metadatashow_logsèdisabled®skip_as_script«code_folded$2e3d4b69-786e-4ccb-91ec-3b98f1f568e0cell_id$2e3d4b69-786e-4ccb-91ec-3b98f1f568e0code
begin
import Pkg
Pkg.activate(mktempdir())
Pkg.add([
Pkg.PackageSpec(name="JuMP", version="0.21"),
Pkg.PackageSpec(name="GLPK", version="0.14"),
Pkg.PackageSpec(name="PlutoUI", version="0.7"),
])
using JuMP, GLPK, PlutoUI
endmetadatashow_logsèdisabled®skip_as_script«code_folded$15037686-c495-42c3-b976-11ac753dde18cell_id$15037686-c495-42c3-b976-11ac753dde18codevalue(model_opt[:x])metadatashow_logsèdisabled®skip_as_script«code_folded$68e07edd-55dd-45d8-9f8a-24ae75a20960cell_id$68e07edd-55dd-45d8-9f8a-24ae75a20960code@bind xmax Slider(1:.01:4)metadatashow_logsèdisabled®skip_as_script«code_folded$267e9766-e2c1-4006-abb0-ae69fba94052cell_id$267e9766-e2c1-4006-abb0-ae69fba94052codemd"""
### Part 2b: make definitions explicit for Pluto
Alternatively, you can manually assign to the variable that is secretly defined to make Pluto understand.
⛔️ Don't:
```julia
begin
model = Model(GLPK.Optimizer)
@variable(model, 20 < y < 30)
# global variable y is now defined, but Pluto does not know it
...
end
```
✔️ Do:
```julia
begin
model = Model(GLPK.Optimizer)
y = @variable(model, 20 < y < 30)
# global variable y is now defined, and Pluto knows it
...
end
```
""" |> opacity(.5)metadatashow_logsèdisabled®skip_as_script«code_foldedënotebook_id$b47c0b74-4aa4-11f0-1152-8f4584eee5fbin_temp_dir¨metadata